home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 076-100 / disk_091 / adlrun / adlstr.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  4KB  |  278 lines
  1. #include <stdio.h>
  2.  
  3. #include "adltypes.h"
  4. #include "adlprog.h"
  5. #include "adldef.h"
  6. #include "builtins.h"
  7. #include "vstring.h"
  8. #include "adlrun.h"
  9.  
  10. extern char
  11.     *malloc();
  12.  
  13. eqstring()
  14. {
  15.     char
  16.     *s;
  17.  
  18.     assertargs( "$eqst", 2 );
  19.     s = malloc( strlen( virtstr( ARG( 1 ) ) ) + 1 );
  20.     if( s == (char *)0 )
  21.     error( 27 );                /* Out of memory */
  22.     strcpy( s, virtstr( ARG( 1 ) ) );
  23.     if( strcmp( s, virtstr( ARG( 2 ) ) ) )
  24.     RETVAL = 0;
  25.     else
  26.     RETVAL = 1;
  27.     free( s );
  28. }
  29.  
  30.  
  31. substring()
  32. {
  33.     char
  34.     *s;
  35.     int
  36.     t;
  37.  
  38.     assertargs( "$subs", 3 );
  39.     t = strlen( virtstr( ARG( 1 ) ) );
  40.     s = malloc( t + 1 );
  41.     if( s == (char *)0 )
  42.     error( 27 );                /* Out of memory */
  43.     strcpy( s, virtstr( ARG( 1 ) ) );
  44.     if( ARG( 2 ) >= t ) {
  45.     ARG( 2 ) = t;
  46.     ARG( 3 ) = 1;
  47.     }
  48.     else if( ((ARG( 2 ) + ARG( 3 )) >= t) || (!ARG( 3 )) )
  49.     ARG( 3 ) = t - ARG( 2 );
  50.     strncpy( s, &s[ ARG( 2 ) ], ARG( 3 ) );
  51.     s[ ARG( 3 ) ] = '\0';
  52.     RETVAL = newtstr( s );
  53.     free( s );
  54. }
  55.  
  56.  
  57. lengstring()
  58. {
  59.     RETVAL = strlen( virtstr( ARG( 1 ) ) );
  60. }
  61.  
  62.  
  63. readstring()
  64. {
  65.     char
  66.     s[ SLEN ];
  67.  
  68.     getstring( s );
  69.     RETVAL = newtstr( s );
  70. }
  71.  
  72.  
  73. catstring()
  74. {
  75.     char
  76.     *s;
  77.  
  78.     assertargs( "$cat", 2 );
  79.     s = malloc( strlen( virtstr( ARG(1) ) ) + strlen( virtstr( ARG(2) ) ) + 1 );
  80.     if( s == (char *)0 )
  81.     error( 27 );                /* Out of memory */
  82.     strcpy( s, virtstr( ARG(1) ) );
  83.     strcat( s, virtstr( ARG(2) ) );
  84.     RETVAL = newtstr( s );
  85.     free( s );
  86. }
  87.  
  88.  
  89. chrstring()
  90. {
  91.     char
  92.     s[ 2 ];
  93.  
  94.     assertargs( "$chr", 1 );
  95.     s[ 0 ] = (char) ARG( 1 );
  96.     s[ 1 ] = '\0';
  97.     RETVAL = newtstr( s );
  98. }
  99.  
  100.  
  101. ordstring()
  102. {
  103.     char
  104.     temp;
  105.  
  106.     assertargs( "$ord", 1 );
  107.     temp = *( virtstr( ARG( 1 ) ) );
  108.     RETVAL = (int16) temp;
  109. }
  110.  
  111.  
  112. int16
  113. strpos( s1, s2 )
  114. char
  115.     *s1, *s2;
  116. {
  117.     char
  118.     *t0,
  119.     *t1,
  120.     *t2;
  121.  
  122.     t0 = s2;
  123.     while( *s2 ) {
  124.     if( *s1 == *s2 ) {
  125.         t1 = s1;
  126.         t2 = s2;
  127.         while( *s1 && *s1 == *s2 ) {
  128.         s1++;
  129.         s2++;
  130.         }
  131.         if( !*s1 )    /* Found it! */
  132.             return (int16) (s2 - t0);
  133.         s1 = t1;
  134.         s2 = t2;
  135.     }
  136.     s2++;
  137.     }
  138.     return -1;
  139. }
  140.  
  141.  
  142. posstring()
  143. {
  144.     char
  145.     *s;
  146.  
  147.     assertargs( "$pos", 2 );
  148.     s = malloc( strlen( virtstr( ARG( 1 ) ) ) + 1 );
  149.     if( s == (char *)0 )
  150.     error( 27 );                /* Out of memory */
  151.     strcpy( s, virtstr( ARG( 1 ) ) );
  152.     RETVAL = strpos( s, virtstr( ARG( 2 ) ) );
  153.     free( s );
  154. }
  155.  
  156.  
  157. savestr()
  158. {
  159.     assertargs( "$savestr", 1 );
  160.     RETVAL = vs_save( ARG( 1 ) );
  161. }
  162.  
  163.  
  164. do_str()
  165. {
  166.     char s[ SLEN ];
  167.  
  168.     assertargs( "$str", 1 );
  169.     (void)sprintf( s, "%d", ARG( 1 ) );
  170.     RETVAL = newtstr( s );
  171. }
  172.  
  173.  
  174. do_num()
  175. {
  176.     assertargs( "$num", 1 );
  177.     RETVAL = atoi( virtstr( ARG( 1 ) ) );
  178. }
  179.  
  180.  
  181. char    bletch[ 10 ];    /* Static store area for xlate */
  182.  
  183. char    *
  184. xlate( s )
  185. char
  186.     *s;
  187. {
  188.     int
  189.     i;
  190.  
  191.     for( i = 0; s[ i ]; i++ )
  192.     bletch[ i ] = ~s[ i ];
  193.     bletch[ i ] = '\0';
  194.     return bletch;
  195. }
  196.  
  197.  
  198. do_name()
  199. {
  200.     char
  201.     s[ 80 ];
  202.     int16
  203.     t;
  204.  
  205.     assertargs( "$name", 1 );
  206. #if DEBUG
  207.     if( (ARG( 1 ) < 0) || (ARG( 1 ) > NUMOBJ) )
  208.     error( 25 );    /* Illegal object for $name */
  209. #endif
  210.     t = objspace[ ARG( 1 ) ].adj;
  211.     if( t < 0 ) {
  212.     strcpy( s, findone( VERB, -t ) );
  213.     strcat( s, " " );
  214.     }
  215.     else if( t ) {
  216.     strcpy( s, findone( ADJEC, t ) );
  217.     strcat( s, " " );
  218.     }
  219.     else
  220.     *s = '\0';
  221.     strcat( s, findone( NOUN, objspace[ ARG( 1 ) ].noun ) );
  222.     RETVAL = newtstr( s );
  223. }
  224.  
  225.  
  226. do_vname()
  227. {
  228.     assertargs( "$vname", 1 );
  229.     RETVAL = newtstr( findone( VERB, ARG( 1 ) ) );
  230. }
  231.  
  232.  
  233. do_mname()
  234. {
  235.     assertargs( "$mname", 1 );
  236.     if( ARG( 1 ) < 0 ) {
  237.     ARG( 1 ) = -ARG( 1 );
  238.     do_vname();
  239.     }
  240.     else if( ARG( 1 ) )
  241.     RETVAL = newtstr( findone( ADJEC, ARG( 1 ) ) );
  242.     else
  243.     RETVAL = newtstr( "" );
  244. }
  245.  
  246.  
  247. do_pname()
  248. {
  249.     assertargs( "$pname", 1 );
  250.     RETVAL = newtstr( findone( PREP, ARG( 1 ) ) );
  251. }
  252.  
  253.  
  254. do_define()
  255. {
  256.     char
  257.     s1[ 80 ],
  258.     s2[ 80 ];
  259.  
  260.     assertargs( "$define", 2 );
  261.     strcpy( s1, virtstr( ARG( 1 ) ) );
  262.     strcpy( s2, virtstr( ARG( 2 ) ) );
  263.     define( s1, s2 );
  264. }
  265.  
  266.  
  267. do_undef()
  268. {
  269.     char
  270.     s[ 80 ];
  271.  
  272.     assertargs( "$undef", 1 );
  273.     strcpy( s, xlate( virtstr( ARG( 1 ) ) ) );
  274.     undef( s );
  275. }
  276.  
  277. /*** EOF adlstr.c ***/
  278.